constructor(connectionConfig: any, fileStoreBaseDir: string) {
  this.pool = new Pool(connectionConfig);
  this.fileStore = new JSONStore(fileStoreBaseDir);
  this.initPromise = this.initialize().catch(err => {
    this.initError = err;
    throw err;  // 这里抛出但没有被处理
  });
}

private async ensureInitialized(): Promise<void> {
  await this.initPromise;
  if (this.initError) {
    throw new Error(`PostgresStore initialization failed: ${this.initError.message}`);
  }
}

async saveMessages(agentId: string, messages: Message[]): Promise<void> {
  await this.ensureInitialized();  // 每个公开方法都要加
  // ... 原有逻辑
}

export interface PostgresConfig {
  host: string;
  port: number;
  database: string;
  user: string;
  password: string;
  ssl?: boolean | { rejectUnauthorized?: boolean };
  max?: number;                    // 连接池最大连接数
  idleTimeoutMillis?: number;      // 空闲连接超时
  connectionTimeoutMillis?: number; // 连接超时
}

constructor(config: PostgresConfig, fileStoreBaseDir: string) {
  const poolConfig = {
    ...config,
    max: config.max ?? 10,
    idleTimeoutMillis: config.idleTimeoutMillis ?? 30000,
    connectionTimeoutMillis: config.connectionTimeoutMillis ?? 5000,
  };
  
  this.pool = new Pool(poolConfig);
  
  // 监听连接池错误，避免未处理的异常
  this.pool.on('error', (err) => {
    console.error('[PostgresStore] Unexpected pool error:', err);
  });
  
  // ...
}

// 记录关键操作状态
interface OperationLog {
  id: string;
  agentId: string;
  operation: 'save_messages' | 'save_info' | 'fork';
  status: 'started' | 'db_committed' | 'fs_committed' | 'completed';
  startedAt: Date;
}

interface StoreHealthStatus {
  healthy: boolean;
  database: { connected: boolean; latencyMs?: number };
  fileSystem: { writable: boolean };
}

async healthCheck(): Promise<StoreHealthStatus>;

async checkConsistency(agentId: string): Promise<{
  consistent: boolean;
  issues: string[];
}>;

function createStore(config: StoreConfig): Store {
  switch (config.type) {
    case 'json': return new JSONStore(config.baseDir);
    case 'sqlite': return new SqliteStore(config.dbPath);
    case 'postgres': return new PostgresStore(config);
  }
}

// PostgreSQL Advisory Lock
async acquireAgentLock(agentId: string): Promise<() => Promise<void>>;

async batchFork(agentId: string, count: number): Promise<string[]>;

interface StoreMetrics {
  operations: { saves: number; loads: number; queries: number };
  performance: { avgLatencyMs: number };
  storage: { totalAgents: number; dbSizeBytes: number };
}